from .base_strategy import BaseStrategy
import backtrader as bt
import backtrader.indicators as btind
import indicator.MyTTIndicator as Mytt
import indicator.myzhibiao as mmm


###
# 10日均线回归策略
# 当价格偏离均线过多，且，出现了上上影线时，则意味着当前价格处于超卖。可以进场卖出
# 
# #
class MyStrategy(BaseStrategy):
    params = (
        ('init_size', 300),         # 初始仓位
        ('first_add_ratio', 30), # 首次加仓比例（10%）
        ('add_multiplier', 1.1),  # 加仓数量倍数（每次增加10%）
        ('add_trigger', 0.01),    # 加仓触发涨幅（1%）
        ('add_distance', 0.97),   # 加仓执行价格比例（0.97表示比触发价低3%）
        ('profit_target', 0.01),  # 整体盈利目标（1%）
        ('max_adds', 50),         # 最大加仓次数
        ('printlog', True),      # 是否打印日志
    )

 
    def __init__(self):
        super().__init__()

        self.order = None
        self.entry_price_my = 0.0    # 开仓价格
        self.total_size = 0.0     # 总仓位
        self.add_positions = []   # 记录加仓信息 [(price, size), ...]
        self.trigger_price = 0.0  # 当前加仓触发价
        self.add_count = 0        # 加仓次数计数器


    def start(self):
        self.entry_price_my = 0.0
        self.total_size = 0.0
        self.add_positions = []
        self.trigger_price = 0.0
        self.add_count = 0

    def notify_order(self, order):
        super().notify_order(order)
        if order.status in [order.Submitted, order.Accepted]:
            return
        if order.status in [order.Completed]:
            self.bar_executed = len(self)
        self.order = None

    def notify_trade(self, trade):
        super().notify_trade(trade)



    def next(self):
        super().next()
        dt =  self.datas[0].datetime.datetime(0)

        if not self.position:  # 开仓逻辑
            self.entry_price_my = self.data.close[0]
            # 计算开仓份额数量
            self.total_size = self.p.init_size / self.entry_price_my
            self.sell(size=self.total_size)

            self.add_positions = [(self.entry_price_my,self.total_size,self.p.init_size)]
            self.trigger_price = self.entry_price_my + self.entry_price_my * self.p.add_trigger # 第一次触发价 = 开仓价+1%
            if self.p.printlog:
                print(f'时间={dt}开空单: 价格={self.entry_price_my:.2f}, 下单={self.p.init_size}u，数量={self.total_size}，下次触发价={self.trigger_price}')
        else:  # 加仓逻辑
            current_price = self.data.close[0]
 
            # 计算平均成本
            avg_cost = sum(p[0] * p[1] for p in self.add_positions) / sum(p[1] for p in self.add_positions)
 
            # 检查盈利目标
            unrealized_pnl_pct = (avg_cost - current_price) / avg_cost
            if unrealized_pnl_pct >= self.p.profit_target:
                self.buy(size=self.total_size)
                self.total_size = 0
                self.add_count = 0
                if self.p.printlog:
                    print(f'时间={dt}达到盈利目标平仓: 价格={current_price:.2f}, 盈利={unrealized_pnl_pct*100:.2f}%')
                return
 
            # 检查是否达到最大加仓次数
            if self.add_count >= self.p.max_adds:
                return
 
            # 检查是否触发加仓（价格达到当前触发价）
            if current_price >= self.trigger_price:
                # 计算加仓数量（首次用first_add_ratio，后续按倍数增加）
                if self.add_count == 0:
                    add_price = self.p.first_add_ratio 
                else:
                    add_price =  self.add_positions[-1][2] * self.p.add_multiplier

                add_size = add_price / current_price
                # 执行加仓
                self.sell(size=add_size)
                self.total_size += add_size
                self.add_positions.append((current_price, add_size,add_price))
                self.add_count += 1
 

 
                if self.p.printlog:
                    print(f'时间={dt} 加仓空单({self.add_count}/{self.p.max_adds}):当前价格={current_price}， 触发价={self.trigger_price:.3f}, 下单={add_price:.5f}U, 数量={add_size:.3f}，平均盈亏={unrealized_pnl_pct*100:.2f}%')
 
                 # 更新下一次触发价（当前触发价 +1%）
                self.trigger_price  = self.trigger_price + self.trigger_price * self.p.add_trigger *self.p.add_distance